Developer CD Series 2000 August: Tool Chest/Dev.CD Aug 00 TC Disk 2.toast/pc/sample code/networking/pgpuam/sources/passphrasecache.c

Text File | 2000-06-23 | 7.4 KB | 293 lines

//    PassphraseCache.c -  Passphrase Cache Interface Object
//
// Apple Macintosh Developer Technical Support
// Written by:  Vinnie Moscaritolo
//
//  Copyright (work in progress)  Apple Computer, Inc All rights reserved.
//
// You may incorporate this sample code into your applications without
// restriction, though the sample code has been provided "AS IS" and the
// responsibility for its operation is 100% yours.  However, what you are
// not permitted to do is to redistribute the source as "DSC Sample Code"
// after having made changes. If you're going to re-distribute the source,
// we require that you make it clear in the source that the code was
// descended from Apple Sample Code, but that you've made changes.
//

#include <string.h>
#include <Timer.h>
#include <CodeFragments.h>
#include <Errors.h>

#define PGP_MACINTOSH 1
#include "pgpkeys.h"
#include "pgpUtilities.h"
#include "pgpMemoryMgr.h"

// dont include the .h else the linker gets confused..
//#include "PassphraseCache.h"

// ---------------------------------------------------------------------------
#pragma mark Exported Symbols
// ---------------------------------------------------------------------------

#ifdef __cplusplus
extern "C" {
#endif

#pragma export on

    OSErr         __passphrasecache_initialize(const CFragInitBlock* initBlock);
    void         __passphrasecache_terminate(void);

    void      FlushPassphraseCache();

    void     EnablePassphraseCaching( Boolean  enable);
    void      SetPassphraseCacheTimeLimit( SInt16 mins);

    void      RememberPassphrase (PGPKeyRef  keyRef, const char* passphrase);

    Boolean  GetPassphrase      (PGPContextRef, PGPKeyRef, char** passphrase);

    pascal OSErr __initialize(const CFragInitBlock *theInitBlock);
    pascal OSErr __terminate(void);


#pragma export off

#ifdef __cplusplus
}
#endif


#define k1Minute        (1000  * 60) /* actually 60 */

// ---------------------------------------------------------------------------
#pragma mark Globals
// ---------------------------------------------------------------------------
    TMTask                gTMTask = {nil,0,nil,0,0};
    long                gCacheTimeLimit;
    UInt32                gWatchdogTick;
    UInt32                gExpired;


     char                gCache[256];


    CFragConnectionID    gConnID         = nil;
    Boolean                gCachingEnabled = false;
    FSSpec                gFragSpec;
    UInt32                 gFragOffset;
    UInt32                gFragLength;

// ---------------------------------------------------------------------------
#pragma mark Local Prototypes
// ---------------------------------------------------------------------------

static void __passphrasecache_timerProc(void);
static void     ResetWatchDog(void);


// ---------------------------------------------------------------------------
static void __passphrasecache_timerProc(void)
// ---------------------------------------------------------------------------
//
{
    FlushPassphraseCache();
//    DebugStr("\pTimer Expires");
}


// ---------------------------------------------------------------------------
 void FlushPassphraseCache()
// ---------------------------------------------------------------------------
//  shutdown  Passphrase Cache Interface Object
{
     gCache[0] = '\0';

}


 // ---------------------------------------------------------------------------
OSErr __passphrasecache_initialize(const CFragInitBlock* initBlock)
// ---------------------------------------------------------------------------
//
//

{
#pragma unused (initBlock)
    OSStatus                ErrNo = noErr;

    ErrNo = __initialize( initBlock );
     if( ErrNo != noErr) return ErrNo;

//DebugStr("\p__passphrasecache_initialize");

    if( initBlock->fragLocator.where != kDataForkCFragLocator)
        {
            DebugStr("\pError Could't load PassphraseCacheLib, wrong frag type?\n");
            return cfragFragmentUsageErr;
        }

    gFragSpec = *initBlock->fragLocator.u.onDisk.fileSpec;
     gFragOffset    = initBlock->fragLocator.u.onDisk.offset,
    gFragLength = initBlock->fragLocator.u.onDisk.length,

    gCache[0] = '\0';

     return ErrNo;
}

// ---------------------------------------------------------------------------
void __passphrasecache_terminate(void)
// ---------------------------------------------------------------------------
//
//

{
//    DebugStr("\p__passphrasecache_terminate");

    if(gTMTask.tmAddr != nil)
    {
        RmvTime((QElemPtr) &gTMTask);
         DisposeRoutineDescriptor(gTMTask.tmAddr);
         gTMTask.tmAddr = nil;
     }

     __terminate();

}

#pragma mark -


// ---------------------------------------------------------------------------
static void ResetWatchDog(void)
// ---------------------------------------------------------------------------
//
{
    if(gCachingEnabled)
    {
        RmvTime((QElemPtr) &gTMTask);
           InsTime((QElemPtr) &gTMTask);
        PrimeTime((QElemPtr)&gTMTask, gCacheTimeLimit);
     }
}

// ---------------------------------------------------------------------------
void EnablePassphraseCaching( Boolean  enable)
// ---------------------------------------------------------------------------
//
{
    THz    saveZone;
    OSStatus    ErrNo = noErr;

// this needs to be done in system heap
    saveZone = GetZone();
    SetZone( SystemZone() );

    if(gCachingEnabled &&  !enable)
    {
        // turn caching off
        RmvTime((QElemPtr) &gTMTask);
         DisposeRoutineDescriptor(gTMTask.tmAddr);
         gTMTask.tmAddr = nil;
         gCachingEnabled = false;
        FlushPassphraseCache();

        CloseConnection(&gConnID);
     }
    else if(enable && !gCachingEnabled)
    {
        ProcPtr codePtr;
        Str255    errorMessage;

// create persistant connection by   increment library  refcount
         ErrNo = GetDiskFragment( &gFragSpec,gFragOffset, gFragLength,
                                "\pPassphraseCacheLib",
                                kReferenceCFrag,
                                &gConnID,
                                &(Ptr)codePtr,
                                errorMessage);
    if (ErrNo != noErr)
        {
            DebugStr("\pError  Could't load PassphraseCacheLib\n");
        }

// start the caching timer up.
        gTMTask.tmAddr         =  NewTimerProc( __passphrasecache_timerProc );
        gCachingEnabled = true;
     }

     SetZone(saveZone);
}

// ---------------------------------------------------------------------------
 void SetPassphraseCacheTimeLimit( SInt16 mins) //  (static public)
// ---------------------------------------------------------------------------
//
{

     gCacheTimeLimit = mins * 1000 /* * 60 */ ;

     if(mins == 0)  // don't cache
     {

      // take this out to cache passphrase
    };

     if(mins == 90)  // no time limit
     {
     };

}



// ---------------------------------------------------------------------------
 void RememberPassphrase(PGPKeyRef  keyRef, const char* passphrase)   //  (static public)
// ---------------------------------------------------------------------------
//
{
     PGPPublicKeyAlgorithm algorithm;
    PGPKeyID              keyID;

    PGPGetKeyNumber (keyRef,  kPGPKeyPropAlgID,  (PGPInt32*) &algorithm);
    PGPGetKeyIDFromKey (keyRef, &keyID );

    strcpy (gCache, passphrase);

      ResetWatchDog();
}

// ---------------------------------------------------------------------------
 Boolean GetPassphrase (PGPContextRef    context, PGPKeyRef  keyRef, char** passphrase)   //  (static public)
// ---------------------------------------------------------------------------
//
{
     PGPPublicKeyAlgorithm algorithm;
    PGPKeyID              keyID;

    ResetWatchDog();

    PGPGetKeyNumber (keyRef,  kPGPKeyPropAlgID,  (PGPInt32*) &algorithm);
    PGPGetKeyIDFromKey (keyRef, &keyID );

    if( strlen(gCache) > 0)
    {

        *passphrase     = (char*) PGPNewSecureData( PGPGetContextMemoryMgr(context),  strlen(gCache) , kPGPMemoryMgrFlags_None );
         strcpy (*passphrase, gCache);
         return true;
    }
//      if(  PGPCompareKeyIDs(keyID, keyID) == 0);



return false;
}